package org.boot.fast.core.api.mapper.provider.process;

import org.boot.fast.core.api.mapper.provider.entity.AnalysisResultInfo;

import java.util.Arrays;
import java.util.Collection;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 处理数组参数：将 #{字段名_array} 替换为多个占位符
 * 例如：#{id_array} 转换为 #{id_0}, #{id_1}, ...
 */
@SuppressWarnings("all")
public class InArrayProcess {
    /**
     * 处理数组参数：将 #{字段名_array} 替换为多个占位符
     */
    public static AnalysisResultInfo toInArraySql(String sql, Map<String, Object> params) {
        // 正则匹配 #{字段名_array}
        Pattern pattern = Pattern.compile("#\\{(\\w+?)_array\\}");
        Matcher matcher = pattern.matcher(sql);
        StringBuffer result = new StringBuffer();

        while (matcher.find()) {
            String fieldName = matcher.group(1); // 获取字段名，如 id
            String arrayParamKey = fieldName + "_array";

            if (!params.containsKey(arrayParamKey)) {
                throw new IllegalArgumentException("缺少数组参数: " + arrayParamKey);
            }

            Object value = params.get(arrayParamKey);
            String[] values = parseArrayValue(value);

            if (values.length == 0) {
                throw new IllegalArgumentException("数组参数不能为空: " + arrayParamKey);
            }

            // 构建IN语句
            StringBuilder inClause = new StringBuilder();
            for (int i = 0; i < values.length; i++) {
                if (i > 0) {
                    inClause.append(", ");
                }

                String newParamName = fieldName + "_" + i;
                inClause.append("#{").append(newParamName).append("}");

                // 将新参数添加到params中
                params.put(newParamName, convertValue(values[i].trim(), value));
            }
            // 替换原占位符
            matcher.appendReplacement(result, Matcher.quoteReplacement(inClause.toString()));
            // 移除原始的数组参数，避免被重复处理
            params.remove(arrayParamKey);
        }

        matcher.appendTail(result);
        return new AnalysisResultInfo(result.toString(), params);
    }

    /**
     * 解析数组值
     */
    private static String[] parseArrayValue(Object value) {
        if (value == null) {
            return new String[0];
        }

        if (value instanceof String) {
            return ((String) value).split("\\s*,\\s*"); // 支持逗号前后有空格
        } else if (value instanceof Collection) {
            Collection<?> collection = (Collection<?>) value;
            return collection.stream()
                    .map(Object::toString)
                    .toArray(String[]::new);
        } else if (value.getClass().isArray()) {
            if (value instanceof Object[]) {
                Object[] array = (Object[]) value;
                String[] result = new String[array.length];
                for (int i = 0; i < array.length; i++) {
                    result[i] = array[i] != null ? array[i].toString() : null;
                }
                return result;
            } else if (value instanceof int[]) {
                int[] array = (int[]) value;
                return Arrays.stream(array).mapToObj(String::valueOf).toArray(String[]::new);
            } else if (value instanceof long[]) {
                long[] array = (long[]) value;
                return Arrays.stream(array).mapToObj(String::valueOf).toArray(String[]::new);
            }
            // 其他基本类型数组可以类似处理
        }

        throw new IllegalArgumentException("不支持的数组参数类型: " + value.getClass().getName());
    }

    /**
     * 转换值类型，保持与原数组类型一致
     */
    private static Object convertValue(String strValue, Object originalValue) {
        if (originalValue instanceof Collection &&
                !((Collection<?>) originalValue).isEmpty()) {
            // 获取集合第一个元素的类型作为参考
            Object firstElement = ((Collection<?>) originalValue).iterator().next();
            return convertByType(strValue, firstElement.getClass());
        } else if (originalValue.getClass().isArray() &&
                !originalValue.getClass().getComponentType().isPrimitive()) {
            // 对象数组
            return convertByType(strValue, originalValue.getClass().getComponentType());
        }

        // 默认返回字符串
        return strValue;
    }

    /**
     * 根据类型转换字符串值
     */
    private static Object convertByType(String strValue, Class<?> type) {
        if (type == Integer.class || type == int.class) {
            return Integer.parseInt(strValue);
        } else if (type == Long.class || type == long.class) {
            return Long.parseLong(strValue);
        } else if (type == Double.class || type == double.class) {
            return Double.parseDouble(strValue);
        } else if (type == Float.class || type == float.class) {
            return Float.parseFloat(strValue);
        } else if (type == Boolean.class || type == boolean.class) {
            return Boolean.parseBoolean(strValue);
        }
        return strValue;
    }
}
